Shareware Grab Bag/Shareware Grab Bag.iso/007/d86.arc/DEMO.DOC

Text File | 1986-08-27 | 11.5 KB | 195 lines

---DEMO.DOC---

To demonstrate some of the powers of D86, let's walk through a D86 session.  You
should print out a copy of this file, DEMO.DOC, and also the file HEXOUT.8.
Using those listings, go through the following steps.  You may wish to check
them off as you go through them, to keep track of where you are.

1. Make sure your current directory contains all the files A86.COM, D86.COM,
   and HEXOUT.8.

2. Assemble the HEXOUT program by typing the command A86 HEXOUT.8.  The A86
   assembler will create the files HEXOUT.COM and HEXOUT.SYM.  Look over the
   listing of the program, to get acquainted with what it does.

3. Now comes the moment of truth, especially if you do not have a real IBM-PC.
   Find out if the debugger works on your machine, by typing the command
   D86 HEXOUT 41 42 5A.

   If all goes well, the screen should blank; and the D86 debugger screen
   should appear.  The blinking cursor should be at the bottom left.  A sign-on
   message should appear at the upper right.  A disassembly of the HEXOUT
   program should be in the upper left.  The label HEXOUT should appear on the
   first line, followed on the second line by the address 0100 and the
   instruction MOV SI,TAIL_BUFF.  To the left of the address should be a
   reverse-video pound sign.  If you don't see all of these things, refer to
   the file TROUBLE.DOC to initiate actions to let me know how I might fix the
   problem.

4. Let's look at what we already have.  Notice the display of register values
   in the lower left corner.  The values are all 4-digit hexadecimal.  At the
   top of the second column of registers is a sequence of lower-case letters.
   This is the flags display.  Each small letter stands for a flag whose value
   is currently TRUE.  The flags settings are those that were handed to D86 by
   the operating system starting the program; for MSDOS V3,1, the settings are
   "i z e".  That display indicates that the interrupt flag "i", the zero flag
   "z", and the parity-even flag "e" are all TRUE; the other flags are FALSE.
   To the right of the registers are six lines labelled 1: through 6:.  These
   are the memory window lines.  Since you haven't specified any memory windows
   yet, they contain nothing but their numbers.  Below the memory-window lines
   is a line labelled 0:.  This is the stack display line. The number 0: gives
   the number of words on the stack, currently zero because nothing has been
   pushed onto the stack.

5. Observe that the sign-on message tells you to press Alt-F10 for help.  Do
   so (that is, hold down the Alt-key while pressing the F10 key).  You are now
   in help-mode, where you will remain until you press Alt-F10 again.  D86 will
   keep changing the help-window, depending on what it thinks you are doing.
   Right now you have a summary of the main function-keys, plus a few other
   things.  Press F10 (without the Alt), and you'll get a summary of one-letter
   debugger commands.  Press F10 a second time to return to the function-key
   help screen.

6. Let's try an immediate assembly-language instruction. Press the "M" key.
   Note that the reverse-video block jumps from the pound-sign within the
   disassembly, down to the line just above the blinking cursor.  The block is
   the debugger's cursor; the blinking cursor is the program's console output
   cursor.  The debugger does not use the blinking cursor because we do not
   want the program's output to interfere with the debugger's output.  Also
   note that the help-window is now telling you that you are typing in an
   assembly-language line.

7. Complete the line MOV AX,123.  The debugger immediately executes the assembly
   language line you just typed, setting the register AX.  Note that you did
   not have to learn a debugger command for setting registers; if you know A86,
   you already know how to set registers!  The value of AX is now 007B, which
   may surprise you if you expected 0123. A86's default base is 10, so 123 was
   taken as decimal; which is hex 7B.  Type MOV AX,0123 instead, to get a value
   of hex 123.

8. Let's now play with the flags display.  Type the line ADD AL,05D, which
   changes AL (the last two digits of AX) to hex 80, and alters the flags to "o
   is a ". The interrupt flag is still on; but zero and parity-even are now
   off.  They have been replaced by "o" overflow, "s" sign, and "a" auxiliary
   carry.

9. Type the line consisting of just CMC.  This is the Complement Carry
   instruction.  Observe that the "c" appears.  Notice also that the CMC that
   you typed remains on the screen.  Notice on the help window the entry "F3
   RepeatCmd".  This tells you that the F3 key will repeat the last line-command
   (not function-key) that you typed.  Press F3 several times, to see the
   carry flag toggle on and off.  Isn't that the cleanest flags display you've
   ever seen?

10. Let's single-step an instruction.  Press the F1 key.  This executes the
   program instruction, loading the SI register with TAIL_BUFF.  The disassembly
   cursor moves down to the next instruction.  Observe that SI has changed to
   0081, which is the pointer to the invocation command-tail, which should
   contain the string typed after HEXOUT: " 41 42 5A" followed by a carriage-
   return code (hex 0D).

11. Let's examine memory to verify that last assertion.  Press the "1" key.
   The cursor jumps to the start of memory-window 1, and the help-window gives
   you a huge choice of memory types to display.  The entry "BtyeHex 2" tells us
   that "B" will cause hex bytes to be displayed.  The "2" indicates that the
   display occupies a fixed number of display bytes for every memory unit,
   namely 2 hex digits.  Type B followed by a comma, to indicate that you want
   nothing but hex bytes to be displayed.  Now the help window asks for a
   segment location.  Let's use the DS register: type DS followed by a comma.
   Now the help window wants an offset within the segment: type SI.  Before
   typing the terminating ENTER, backspace-out what you have typed, and watch
   the help-windows regress appropriately.  Isn't that impressive?  Now retype
   the line, "B,DS,SI".  Note that when you press ENTER, the line fills out
   with hex values: 20 34 31 20 34 32 20 35 41 0D etc.  (61 instead of 41 is
   OK; it means you typed the invocation in lower-case.)

12. Let's look at the same line, displayed as text.  Type "2", moving to memory
   line 2, then type the line "T,SI".  This time you specified type T for text,
   and you left out the segment-register specification.  D86 uses DS when you
   leave out the segment register; so in this case you'll get the same segment.
   This time the display starts with "41 42 5AM"; the "M" is the carriage-
   return, which is control-M, ambiguously displayed.  You can read MEMORY.DOC
   later on for descriptions of all the types, including other text types
   allowing non-ambiguous displays.

13. Let's execute the next instruction, CALL GET_HEX.  Here we have a choice,
   between executing the procedure all at once, or stepping into the procedure
   to execute its instructions one at a time.  Let's try stepping in first:
   type the F1 key.  The cursor jumps to location GET_HEX, on the same
   disassembly screen.  The SP register decrements from FFFE to FFFC, and
   a value 0106 appears on the stack.  This is the return address, pointing
   to the instruction following CALL GET_HEX.

14. Watch memory lines 1 and 2 as you press F1 again, single-stepping the LODSB
   instruction.  You had set up the lines to be pointed to by SI.  Since SI
   changes when LODSB is executed, the memory-displays advance to the next byte.
   Note that the AL register contains the value hex 20, a blank.

15. In a normal debugging session, we would continue stepping within GET_HEX,
   but let's not do that right now.  Instead, press the F6 "TrapRet" key, which
   starts the program going, trapping at the return address on top of the stack,
   which was 0106.  The cursor jumps back up to location 0106, the value is
   no longer on the stack, and SI and the memory-displays have advanced to 0084.

16. Let's try the classic "G" command, common to all debuggers.  Type the line
   "G,0103", noticing the help-windows as you go along.  After you press ENTER,
   the program runs until it gets back to the trap address you provided, 0103.
   Note that the program has called OUT_VALUE to output the "A" that corresponds
   to your input hex 41.  The "A" appears on the bottom line, and the blinking
   cursor advances.

17. Let's execute the next CALL GET_HEX all at once, by pressing the F2 ProcStep
   key.  SI advances again, and AL is loaded with the next value 42.

18. Notice that the disassembly is symbolic: the display is CALL GET_HEX, not
   CALL 0112 as lesser debuggers might give you.  Let's try symbolic input:
   type the line "B,HEX_DIGIT?", causing the debugger to set a fixed trap at
   location HEX_DIGIT?.  Now set your program running with a simple G followed
   by the ENTER key.  The program traps at HEX_DIGIT?. Since this location is
   not in the disassembly window, the window is regenerated, and the cursor
   placed at HEX_DIGIT?.  The memory displays now point to the final number
   "5A".

19. Press F3 to repeat the G-command.  The program traps at HEX_DIGIT? again,
   with SI advanced to the "A".  Press F3 again; advancing SI to the final
   carriage-return.

20. Press F3 yet again.  Since HEX_DIGIT? is never reached again, the program
   runs to its completion.  D86 automatically traps at the EXIT instruction:
   in this case, it is INT 021 with the AH register set to hex 4C, the function
   number for EXIT.  If we try to start the program again from here, we will
   be frozen here: we must issue the Q command to exit the session.  Don't
   do it yet, though.

21. Before exiting, let's check out HEX_DIGIT? more thoroughly.  First, we
   clear the breakpoint we set, by typing "B" followed by the ENTER key.

22. Type the command line "J 0200", jumping to a scratch-pad memory area.  Then
   press the F7 key, entering Patch Memory mode.  The cursor moves into the
   disassembled instruction, signalling that whatever you type is clobbering
   it.

23. Type in the lines "INC BL", "MOV AL,BL", and "JMP HEX_DIGIT?".  Press ENTER
   at the beginning of the fourth line, exiting Patch Memory mode.  The cursor
   will return to the left of the 0200 INC BL line.

24. Type the immediate command "MOV BL,'0'-2".  The BL register should change
   to the evaluated value, hex 2E.

25. Execute the patch-subroutine by typing the line "CALL 0200".  The value BL
   increments to 2F, which is one less than the lowest digit, '0'.  The
   Carry flag is set, indicating that HEX_DIGIT? has correctly judged 2F not
   to be a hex digit.  Now press F3 repeatly, executing your patched subroutine
   for each decimal digit.  The "c" will disappear as the values advance; and
   AL will hold the correct binary value for each hex digit BL.  When BL reaches
   3A, the "c" comes back on again, indicating that we are beyond the decimal
   digits.  When BL reaches 41, "c" goes off, and AL values of 10 through 15
   are displayed.  When BL reaches "47" "c" comes on yet again, because G is
   not a decimal digit.  Type "MOV BL,05F", followed by "CALL 0200", followed
   by F3 several more times to verify correct action for the range of lower-
   case 'a' through 'f'.  You have, relatively quickly, done a thorough test of
   HEX_DIGIT?.  How long would that have taken on a lesser debugger?

26. Type Q followed by ENTER to exit the debugger.